﻿using System;
using System.IO;

namespace Black.NBT
{
    /// <summary>
    /// Représente un TAG_Float
    /// </summary>
    public class TagFloat : Tag, ICloneable
    {
        #region Propriétés

        /// <summary>
        /// Obtient ou définit sa valeur
        /// </summary>
        public float Value
        {
            get
            {
                return (this._value);
            }
            set
            {
                if (this._value != value)
                {
                    this._value = value;
                    this.OnPropertyChanged();
                }
            }
        }

        #endregion

        #region Variables d'instances

        private float _value;

        #endregion

        #region Constructeur de la classe

        /// <summary>
        /// Constructeur de la classe
        /// </summary>
        /// <param name="name">Nom du tag</param>
        public TagFloat(string name)
            : this(name, default(float))
        {
        }

        /// <summary>
        /// Constructeur de la classe
        /// </summary>
        /// <param name="name">Nom du tag</param>
        /// <param name="value">Valeur du tag</param>
        public TagFloat(string name, float value)
            : base(name)
        {
            this.TagType = NBT.TagType.Float;
            this.Value = value;
        }

        #endregion

        #region Fonctions internes

        /// <summary>
        /// Ecrit l'instance sur le stream
        /// </summary>
        /// <param name="stream">Instance du flux</param>
        /// <param name="fromList">Si l'écriture vient d'une liste</param>
        internal override void WriteToStream(MemoryStream stream, bool fromList)
        {
            // Si pas d'une liste on inscrit tout 

            if (!fromList)
            {
                // Ecriture du type

                stream.WriteByte((byte)this.TagType);

                // Ecriture du nom


                NBTFile.WriteString(stream, this.Name);
            }

            // Ecriture de la valeur

            NBTFile.WriteFloat(stream, this.Value);
        }

        #endregion

        #region Fonctions statiques

        /// <summary>
        /// Lit le tag dans le flux
        /// </summary>
        /// <param name="stream">Instance du flux placé</param>
        /// <returns>Instance du Tag</returns>
        public static TagFloat Read(MemoryStream stream)
        {
            return (TagFloat.Read(stream, true));
        }

        /// <summary>
        /// Lit le tag dans le flux
        /// </summary>
        /// <param name="stream">Instance du flux placé</param>
        /// <param name="withName">TRUE récupère le nom, FALSE sinon</param>
        /// <returns>Instance du Tag</returns>
        public static TagFloat Read(MemoryStream stream, bool withName)
        {
            // On récupère son nom

            string name = string.Empty;

            if (withName)
                name = Tag.ReadName(stream);

            // Création de l'instance

            TagFloat item = new TagFloat(name);
            item.Value = NBTFile.ReadFloat(stream);

            // On retourne la valeur

            return (item);
        }

        #endregion

        #region Clonage

        /// <summary>
        /// Clone l'instance
        /// </summary>
        /// <returns>Nouvelle instance</returns>
        object ICloneable.Clone()
        {
            return (this.Clone());
        }

        /// <summary>
        /// Clone l'instance
        /// </summary>
        /// <returns>Nouvelle instance</returns>
        public virtual TagFloat Clone()
        {
            TagFloat clone = this.MemberwiseClone() as TagFloat;

            return (clone);
        }

        #endregion
    }
}
